home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / tiff / tif_unix.c < prev    next >
C/C++ Source or Header  |  1995-06-21  |  5KB  |  206 lines
  1. /* $Header: /usr/people/sam/tiff/libtiff/RCS/tif_unix.c,v 1.10 1994/09/17 23:22:37 sam Exp $ */
  2.  
  3. /*
  4.  * Copyright (c) 1988, 1989, 1990, 1991, 1992, 1993, 1994 Sam Leffler
  5.  * Copyright (c) 1991, 1992, 1993, 1994 Silicon Graphics, Inc.
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and 
  8.  * its documentation for any purpose is hereby granted without fee, provided
  9.  * that (i) the above copyright notices and this permission notice appear in
  10.  * all copies of the software and related documentation, and (ii) the names of
  11.  * Sam Leffler and Silicon Graphics may not be used in any advertising or
  12.  * publicity relating to the software without the specific, prior written
  13.  * permission of Sam Leffler and Silicon Graphics.
  14.  * 
  15.  * THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND, 
  16.  * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY 
  17.  * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.  
  18.  * 
  19.  * IN NO EVENT SHALL SAM LEFFLER OR SILICON GRAPHICS BE LIABLE FOR
  20.  * ANY SPECIAL, INCIDENTAL, INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND,
  21.  * OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  22.  * WHETHER OR NOT ADVISED OF THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF 
  23.  * LIABILITY, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 
  24.  * OF THIS SOFTWARE.
  25.  */
  26.  
  27. /*
  28.  * TIFF Library UNIX-specific Routines.
  29.  */
  30. #include "tiffiop.h"
  31. #include <unistd.h>
  32. #include <stdlib.h>
  33.  
  34. static tsize_t
  35. _tiffReadProc(thandle_t fd, tdata_t buf, tsize_t size)
  36. {
  37.     return ((tsize_t) read((int) fd, buf, (size_t) size));
  38. }
  39.  
  40. static tsize_t
  41. _tiffWriteProc(thandle_t fd, tdata_t buf, tsize_t size)
  42. {
  43.     return ((tsize_t) write((int) fd, buf, (size_t) size));
  44. }
  45.  
  46. static toff_t
  47. _tiffSeekProc(thandle_t fd, toff_t off, int whence)
  48. {
  49.     return ((toff_t) lseek((int) fd, (off_t) off, whence));
  50. }
  51.  
  52. static int
  53. _tiffCloseProc(thandle_t fd)
  54. {
  55.     return (close((int) fd));
  56. }
  57.  
  58. #include <sys/stat.h>
  59.  
  60. static toff_t
  61. _tiffSizeProc(thandle_t fd)
  62. {
  63. #ifdef _AM29K
  64.     long fsize;
  65.     return ((fsize = lseek((int) fd, 0, SEEK_END)) < 0 ? 0 : fsize);
  66. #else
  67.     struct stat sb;
  68.     return (toff_t) (fstat((int) fd, &sb) < 0 ? 0 : sb.st_size);
  69. #endif
  70. }
  71.  
  72. #ifdef MMAP_SUPPORT
  73. #include <sys/mman.h>
  74.  
  75. static int
  76. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  77. {
  78.     toff_t size = _tiffSizeProc(fd);
  79.     if (size != (toff_t) -1) {
  80.         *pbase = (tdata_t)
  81.             mmap(0, size, PROT_READ, MAP_SHARED, (int) fd, 0);
  82.         if (*pbase != (tdata_t) -1) {
  83.             *psize = size;
  84.             return (1);
  85.         }
  86.     }
  87.     return (0);
  88. }
  89.  
  90. static void
  91. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  92. {
  93.     (void) munmap(base, (off_t) size);
  94. }
  95. #else /* !MMAP_SUPPORT */
  96. static int
  97. _tiffMapProc(thandle_t fd, tdata_t* pbase, toff_t* psize)
  98. {
  99.     return (0);
  100. }
  101.  
  102. static void
  103. _tiffUnmapProc(thandle_t fd, tdata_t base, toff_t size)
  104. {
  105. }
  106. #endif /* !MMAP_SUPPORT */
  107.  
  108. /*
  109.  * Open a TIFF file descriptor for read/writing.
  110.  */
  111. TIFF*
  112. TIFFFdOpen(int fd, const char* name, const char* mode)
  113. {
  114.     TIFF* tif;
  115.  
  116.     tif = TIFFClientOpen(name, mode,
  117.         (thandle_t) fd,
  118.         _tiffReadProc, _tiffWriteProc,
  119.         _tiffSeekProc, _tiffCloseProc, _tiffSizeProc,
  120.         _tiffMapProc, _tiffUnmapProc);
  121.     if (tif)
  122.         tif->tif_fd = fd;
  123.     return (tif);
  124. }
  125.  
  126. /*
  127.  * Open a TIFF file for read/writing.
  128.  */
  129. TIFF*
  130. TIFFOpen(const char* name, const char* mode)
  131. {
  132.     static const char module[] = "TIFFOpen";
  133.     int m, fd;
  134.  
  135.     m = _TIFFgetMode(mode, module);
  136.     if (m == -1)
  137.         return ((TIFF*)0);
  138. #ifdef _AM29K
  139.     fd = open(name, m);
  140. #else
  141.     fd = open(name, m, 0666);
  142. #endif
  143.     if (fd < 0) {
  144.         TIFFError(module, "%s: Cannot open", name);
  145.         return ((TIFF *)0);
  146.     }
  147.     return (TIFFFdOpen(fd, name, mode));
  148. }
  149.  
  150. void*
  151. _TIFFmalloc(size_t s)
  152. {
  153.     return (malloc(s));
  154. }
  155.  
  156. void
  157. _TIFFfree(void* p)
  158. {
  159.     free(p);
  160. }
  161.  
  162. void*
  163. _TIFFrealloc(void* p, size_t s)
  164. {
  165.     return (realloc(p, s));
  166. }
  167.  
  168. void
  169. _TIFFmemset(void* p, int v, size_t c)
  170. {
  171.     memset(p, v, c);
  172. }
  173.  
  174. void
  175. _TIFFmemcpy(void* d, const void* s, size_t c)
  176. {
  177.     memcpy(d, s, c);
  178. }
  179.  
  180. int
  181. _TIFFmemcmp(const void* p1, const void* p2, size_t c)
  182. {
  183.     return (memcmp(p1, p2, c));
  184. }
  185.  
  186. static void
  187. unixWarningHandler(const char* module, const char* fmt, va_list ap)
  188. {
  189.     if (module != NULL)
  190.         fprintf(stderr, "%s: ", module);
  191.     fprintf(stderr, "Warning, ");
  192.     vfprintf(stderr, fmt, ap);
  193.     fprintf(stderr, ".\n");
  194. }
  195. TIFFErrorHandler _TIFFwarningHandler = unixWarningHandler;
  196.  
  197. static void
  198. unixErrorHandler(const char* module, const char* fmt, va_list ap)
  199. {
  200.     if (module != NULL)
  201.         fprintf(stderr, "%s: ", module);
  202.     vfprintf(stderr, fmt, ap);
  203.     fprintf(stderr, ".\n");
  204. }
  205. TIFFErrorHandler _TIFFerrorHandler = unixErrorHandler;
  206.